﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;


namespace Model
{
    public abstract class Obstakel
    {
        protected Point[] punten;
        protected double[] hoeken1;
        protected double[] hoeken2;
        protected bool perfecteRechthoek;
        
        public Point[] Punten
        {
            get { return punten; }
            set { punten = value; }
        }

        protected void BerekenCoefficienten()
        {
            if (!perfecteRechthoek)
            {
                hoeken1 = new double[2];
                hoeken2 = new double[2];
                //het y verschil
                double overstaande = punten[0].Y - punten[1].Y;
                //het x verschil
                double aanliggende = punten[1].X - punten[0].X;
                hoeken1[0] = Math.Atan(overstaande / aanliggende);

                overstaande = punten[3].Y - punten[0].Y;
                aanliggende = punten[3].X - punten[0].X;
                hoeken1[1] = Math.Atan(overstaande / aanliggende);

                overstaande = punten[2].Y - punten[1].Y;
                aanliggende = punten[2].X - punten[1].X;
                hoeken2[0] = Math.Atan(overstaande / aanliggende);

                overstaande = punten[3].Y - punten[2].Y;
                aanliggende = punten[2].X - punten[3].X;
                hoeken2[1] = Math.Atan(overstaande / aanliggende);
            }

        }

        public bool binnenRek(Point plaats)
        {
            if (perfecteRechthoek)
            {
                return EvenRek(plaats);
            }
            else
            {
                return OnEvenRek(plaats);
            }
        }

        public bool OnEvenRek(Point plaats)
        {
            double overstaande;
            double aanliggende;
            bool boven1;
            if (plaats.X == punten[0].X || plaats.Y == punten[0].Y) { }
            if (plaats.X == punten[0].X && plaats.Y == punten[0].Y || (plaats.X == punten[2].Y) && (plaats.Y == punten[2].Y)) { return true; }
            if (plaats.Y < punten[0].Y)
            {
                overstaande = punten[0].Y - plaats.Y;
                boven1 = true;
            }
            else
            {
                overstaande = plaats.Y - punten[0].Y;
                boven1 = false;
            }
            if (plaats.X > punten[0].X)
            {
                aanliggende = plaats.X - punten[0].X;
                double temp = Math.Atan(overstaande / aanliggende);
                if (boven1)
                {
                    if (temp > hoeken1[0]) { return false; }
                }
                else
                {
                    if (temp > hoeken1[1]) { return false; }
                }
            }
            else
            {
                return false;
            }

            if (plaats.X == punten[2].X || plaats.Y == punten[2].Y) { }
            if (plaats.Y < punten[2].Y)
            {
                overstaande = punten[2].Y - plaats.Y;
                boven1 = true;
            }
            else
            {
                overstaande = plaats.Y - punten[2].Y;
                boven1 = false;
            }
            if (plaats.X < punten[2].X)
            {
                aanliggende = punten[2].X - plaats.X;
                double temp = Math.Atan(overstaande / aanliggende);
                if (boven1)
                {
                    if (temp > hoeken1[0]) { return false; }
                }
                else
                {
                    if (temp > hoeken1[1]) { return false; }
                }
            }
            else
            {
                return false;
            }
            return true;
        }

        public bool EvenRek(Point plaats)
        {
            return false;
        }

        protected void Orden()
        {
            Point[] temp = new Point[4];

            // De rechter wordt bepaald
            int t1 = Math.Min(punten[0].X, punten[1].X);
            int t2 = Math.Min(punten[2].X, punten[3].X);
            int tr = Math.Min(t2, t1);

            // De bovenste wordt bepaald
            t1 = Math.Min(punten[0].Y, punten[1].Y);
            t2 = Math.Min(punten[2].Y, punten[3].Y);
            int tb = Math.Min(t2, t1);

            // De linker wordt bepaald
            t1 = Math.Max(punten[0].X, punten[1].X);
            t2 = Math.Max(punten[2].X, punten[3].X);
            int tl = Math.Max(t2, t1);

            // De onderste wordt bepaald
            t1 = Math.Max(punten[0].Y, punten[1].Y);
            t2 = Math.Max(punten[2].Y, punten[3].Y);
            int to = Math.Max(t2, t1);

            //alle punten worden doorlopen
            for (int i = 0; i < 4; i++)
            {
                if (tr == punten[i].X) { temp[0] = punten[i]; }
                if (tb == punten[i].Y) { temp[1] = punten[i]; }
                if (tl == punten[i].X) { temp[2] = punten[i]; }
                if (to == punten[i].Y) { temp[3] = punten[i]; }
            }
        }

        protected bool checker(Point[] hoeken)
        {
            return (hoeken[0].X == hoeken[1].X || hoeken[1].X == hoeken[2].X || hoeken[2].X == hoeken[3].X || hoeken[0].X == hoeken[2].X || hoeken[0].X == hoeken[3].X || hoeken[1].X == hoeken[3].X || hoeken[0].Y == hoeken[1].Y || hoeken[1].Y == hoeken[2].Y || hoeken[2].Y == hoeken[3].Y || hoeken[0].Y == hoeken[2].Y || hoeken[0].Y == hoeken[3].Y || hoeken[1].Y == hoeken[3].Y);
        }

    }
}
